// 公共方法文件，解构导出

/**
 * 判断是否拥有此className
 * @param {dom元素} elements
 * @param {class名称} cName
 */
const hasClass = (elements, cName) => {
    return !!elements.className.match(new RegExp('(\\s|^)' + cName + '(\\s|$)'))
  }
  
  /**
   * 添加此className
   * @param {dom元素} elements
   * @param {class名称} cName
   */
  const addClass = (elements, cName) => {
    if (!this.hasClass(elements, cName)) {
      elements.className += ' ' + cName
    }
  }
  
  /**
   * 删除此className
   * @param {dom元素} elements
   * @param {class名称} cName
   */
  const removeClass = (elements, cName) => {
    if (this.hasClass(elements, cName)) {
      elements.className = elements.className.replace(new RegExp('(\\s|^)' + cName + '(\\s|$)'), ' ')
    };
  }
  
  /**
   * 处理string类型的replace工作，可扩展
   * @param {String} type 处理正则表达式switch条件
   * @param {String, Array, Object} data 需要替换处理的对象，指针传递自行深克隆
   */
  const doStringReplace = (type, data) => {
    let reg
    switch (type) {
      case 'space':
        reg = /\s+/g // 匹配空格
        break
      default:
        break
    }
    if (Object.prototype.toString.call(data) === '[object String]') {
      data = data.replace(reg, '')
    } else if (Object.prototype.toString.call(data) === '[object Array]') {
      data.map((item, index) => {
        data[index] = this.doStringReplace(type, item)
      })
    } else if (Object.prototype.toString.call(data) === '[object Object]') {
      Object.keys(data).map((item, index) => {
        data[item] = this.doStringReplace(type, data[item])
      })
    }
    return data
  }
  
  /**
   * 传入函数和时间，对函数进行节流，默认每1秒最多执行一次
   * @param {Function} fn 节流函数
   * @param {Number} waitTime 节流默认时间
   */
  const throttle = (fn, waitTime = 500) => {
    let lastTime = null
    return function () {
      const context = this
      const args = arguments
      let startTime = +new Date()
      if (startTime - lastTime > waitTime || !lastTime) {
        fn.apply(context, args)
        lastTime = startTime
      }
    }
  }
  
  /**
   * 传入函数和时间，对函数进行防抖，默认函数停止触发后300毫秒执行
   * @param {Function} fn 防抖函数
   * @param {Number} wait 防抖默认时间
   */
  const debounce = (fn, wait = 300) => {
    let timer = null
    return function () {
      const context = this
      const args = arguments
      if (timer) {
        clearTimeout(timer)
        timer = null
      }
      timer = setTimeout(function () {
        fn.apply(context, args)
      }, wait)
    }
  }
  
  export {
    hasClass,
    addClass,
    removeClass,
    doStringReplace,
    throttle,
    debounce
  }
  